/**
 * 诊断相关路由
 */
const express = require('express');
const router = express.Router();
const aiDiagnosis = require('../services/aiDiagnosis');
const diseaseInfo = require('../services/diseaseInfo');

module.exports = function(pool) {
  /**
   * 获取植物病害信息
   */
  router.get('/info', async (req, res) => {
    const { plantName } = req.query;
    
    if (!plantName) {
      return res.status(400).json({
        success: false,
        message: '缺少植物名称参数'
      });
    }
    
    try {
      const result = await diseaseInfo.getDiseaseInfo(pool, plantName);
      return res.json(result);
    } catch (err) {
      return res.status(500).json({
        success: false,
        message: '服务器内部错误',
        error: err.message
      });
    }
  });

  /**
   * AI植物诊断接口
   */
  router.post('/ai', async (req, res) => {
    const { plantName, imageBase64, region, season, plantInfo } = req.body;
    
    if (!plantName) {
      return res.status(400).json({
        success: false,
        message: '缺少植物名称参数'
      });
    }

    // 增加对图片数据的更严格验证
    if (!imageBase64) {
      console.error('缺少图片数据');
      return res.status(400).json({
        success: false,
        message: '缺少图片数据'
      });
    }
    
    // 检查imageBase64是否为字符串类型
    if (typeof imageBase64 !== 'string') {
      console.error(`图片数据类型错误: ${typeof imageBase64}`);
      return res.status(400).json({
        success: false,
        message: '图片数据格式错误，必须是Base64编码的字符串'
      });
    }

    console.log(`接收到诊断请求: 植物=${plantName}, 图像数据长度=${imageBase64.length}`);
    
    try {
      console.log(`开始AI诊断: ${plantName}`);
      
      // 调用AI服务进行诊断，传入阿里云识别的植物信息
      const aiResponse = await aiDiagnosis.diagnose(
        plantName, imageBase64, region, season, plantInfo
      );
      
      console.log(`AI诊断完成，返回结果长度: ${aiResponse.fullContent?.length || 0}, 响应时间: ${aiResponse.responseTime}ms`);
      
      return res.json({
        success: true,
        result: {
          plantName: plantName,
          aiDiagnosis: aiResponse.diagnosis,
          treatment: aiResponse.treatment,
          preventionTips: aiResponse.preventionTips,
          growthAdvice: aiResponse.growthAdvice,
          fullContent: aiResponse.fullContent,
          responseTime: aiResponse.responseTime || 0  // 确保响应时间被传递
        }
      });
    } catch (err) {
      // 增强错误处理，返回更多详细信息
      console.error('AI诊断错误:', err);
      console.error('错误详情:', err.stack);
      
      return res.status(500).json({
        success: false,
        message: 'AI诊断服务错误',
        error: err.message,
        errorDetails: err.stack
      });
    }
  });

  /**
   * 使用豆包模型识别植物种类（阿里云识别失败的备用方案）
   */
  router.post('/identify-with-doubao', async (req, res) => {
    const { imageBase64 } = req.body;
    
    if (!imageBase64) {
      return res.status(400).json({
        success: false,
        message: '缺少图片数据'
      });
    }
    
    try {
      console.log(`开始使用豆包识别植物，图像数据长度=${imageBase64.length}`);
      
      const plantInfo = await aiDiagnosis.identifyPlantWithDoubao(imageBase64);
      
      console.log(`豆包植物识别完成，植物名称: ${plantInfo.cname}, 响应时间: ${plantInfo.responseTime}ms`);
      
      return res.json({
        success: true,
        result: {
          name: plantInfo.cname,
          latin: plantInfo.latin,
          family: plantInfo.family,  // 确保科属信息被传递
          features: plantInfo.features,
          isPlant: plantInfo.isPlant,
          score: 0.8, // 默认置信度
          fullContent: plantInfo.fullContent,
          responseTime: plantInfo.responseTime || 0  // 确保响应时间被传递
        }
      });
    } catch (err) {
      console.error('豆包植物识别失败:', err);
      return res.status(500).json({
        success: false,
        message: '豆包植物识别服务出错',
        error: err.message
      });
    }
  });

  /**
   * 启动植物识别任务 - 支持长时间处理
   */
  router.post('/start-identify-task', async (req, res) => {
    const { imageBase64 } = req.body;
    
    if (!imageBase64) {
      return res.status(400).json({
        success: false,
        message: '缺少图片数据'
      });
    }
    
    try {
      console.log(`开始启动植物识别任务，图像数据长度=${imageBase64.length}`);
      
      // 生成任务ID
      const taskId = 'task_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9);
      
      // 将任务存入内存或数据库，标记为进行中
      // 这里简单示例，实际应使用Redis或数据库存储
      if (!global.taskMap) {
        global.taskMap = new Map();
      }
      
      global.taskMap.set(taskId, {
        status: 'processing',
        startTime: Date.now(),
        imageBase64: imageBase64
      });
      
      // 异步处理植物识别，不阻塞响应
      setTimeout(async () => {
        try {
          // 调用AI服务进行识别
          const plantInfo = await aiDiagnosis.identifyPlantWithDoubao(imageBase64);
          
          // 更新任务状态为完成
          global.taskMap.set(taskId, {
            status: 'completed',
            result: plantInfo,
            endTime: Date.now()
          });
          
          console.log(`植物识别任务完成，taskId=${taskId}`);
        } catch (err) {
          console.error('植物识别任务处理失败:', err);
          
          // 更新任务状态为失败
          global.taskMap.set(taskId, {
            status: 'failed',
            error: err.message,
            endTime: Date.now()
          });
        }
      }, 0);
      
      // 立即返回任务ID
      return res.json({
        success: true,
        taskId: taskId,
        message: '任务已启动'
      });
    } catch (err) {
      console.error('启动植物识别任务失败:', err);
      return res.status(500).json({
        success: false,
        message: '启动植物识别任务失败',
        error: err.message
      });
    }
  });
  
  /**
   * 检查植物识别任务结果
   */
  router.get('/check-task-result', (req, res) => {
    const { taskId } = req.query;
    
    if (!taskId) {
      return res.status(400).json({
        success: false,
        message: '缺少任务ID'
      });
    }
    
    try {
      // 从内存或数据库获取任务状态
      if (!global.taskMap || !global.taskMap.has(taskId)) {
        return res.status(404).json({
          success: false,
          message: '任务不存在'
        });
      }
      
      const task = global.taskMap.get(taskId);
      
      // 根据任务状态返回不同响应
      if (task.status === 'processing') {
        return res.json({
          success: true,
          status: 'processing',
          message: '任务处理中'
        });
      } else if (task.status === 'completed') {
        // 返回识别结果
        return res.json({
          success: true,
          status: 'completed',
          result: task.result,
          message: '任务已完成'
        });
      } else {
        // 任务失败
        return res.json({
          success: false,
          status: 'failed',
          message: '任务处理失败',
          error: task.error || '未知错误'
        });
      }
    } catch (err) {
      console.error('检查任务状态失败:', err);
      return res.status(500).json({
        success: false,
        message: '检查任务状态失败',
        error: err.message
      });
    }
  });
  
  return router;
};
